package com.charm.restaurant.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.charm.restaurant.common.Result;
import com.charm.restaurant.entity.Order;
import com.charm.restaurant.entity.OrderDetail;
import com.charm.restaurant.mapper.OrderDetailMapper;
import com.charm.restaurant.mapper.OrderMapper;
import com.charm.restaurant.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;

/**
 * 订单服务实现类
 */
@Slf4j
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {

    @Autowired
    private OrderDetailMapper orderDetailMapper;

    /**
     * 用户下单
     */
    @Override
    @Transactional
    public Result<String> submit(Order order) {
        try {
            // 设置订单号、下单时间、状态等信息
            String orderNumber = "DD" + System.currentTimeMillis();
            order.setNumber(orderNumber);
            order.setStatus(1); // 1表示待接单
            order.setOrderTime(LocalDateTime.now());

            // 如果没有设置用户ID，使用默认值
            if (order.getUserId() == null) {
                order.setUserId(1L); // 默认用户ID
            }

            // 如果没有设置商家ID，使用默认值
            if (order.getMerchantId() == null) {
                order.setMerchantId(1L); // 默认商家ID
            }

            log.info("准备保存订单：{}", order);

            // 保存订单
            this.save(order);

            // 获取订单ID
            Long orderId = order.getId();

            // 处理订单详情
            if (order.getOrderDetails() != null && !order.getOrderDetails().isEmpty()) {
                for (OrderDetail detail : order.getOrderDetails()) {
                    // 设置订单ID
                    detail.setOrderId(orderId);

                    // 保存订单详情
                    orderDetailMapper.insert(detail);
                }
                log.info("保存订单详情成功，数量：{}", order.getOrderDetails().size());
            } else {
                log.warn("订单没有详情项");
            }

            log.info("订单创建成功，订单号：{}", orderNumber);
            return Result.success("下单成功");
        } catch (Exception e) {
            log.error("下单失败", e);
            return Result.error("下单失败：" + e.getMessage());
        }
    }

    /**
     * 用户查询自己的订单
     */
    @Override
    public Result<Page<Order>> userPage(int page, int pageSize) {
        // 模拟获取当前登录用户ID
        Long userId = 1L;

        // 创建分页对象
        Page<Order> pageInfo = new Page<>(page, pageSize);

        // 创建条件构造器
        LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Order::getUserId, userId);
        queryWrapper.orderByDesc(Order::getOrderTime);

        // 执行分页查询
        this.page(pageInfo, queryWrapper);

        // 确保总数正确
        if (pageInfo.getTotal() == 0 && pageInfo.getRecords() != null && !pageInfo.getRecords().isEmpty()) {
            log.warn("分页查询返回了记录但总数为0，设置总数为记录数量: {}", pageInfo.getRecords().size());
            // 这里不能直接修改total，因为它是通过方法获取的，我们可以在日志中记录这个问题
        }

        log.info("用户订单分页查询结果: 总数={}, 当前页记录数={}",
                pageInfo.getTotal(), pageInfo.getRecords() != null ? pageInfo.getRecords().size() : 0);

        return Result.success(pageInfo);
    }

    /**
     * 商家查询订单
     */
    @Override
    public Result<Page<Order>> merchantPage(int page, int pageSize, String number, Integer status, String beginTime, String endTime) {
        // 模拟获取当前登录商家ID
        Long merchantId = 1L;

        // 创建分页对象
        Page<Order> pageInfo = new Page<>(page, pageSize);

        // 创建条件构造器
        LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Order::getMerchantId, merchantId);

        // 根据订单号查询
        queryWrapper.like(number != null, Order::getNumber, number);

        // 根据订单状态查询
        queryWrapper.eq(status != null, Order::getStatus, status);

        // 根据时间范围查询
        if (beginTime != null && endTime != null) {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime begin = LocalDateTime.parse(beginTime, formatter);
            LocalDateTime end = LocalDateTime.parse(endTime, formatter);
            queryWrapper.between(Order::getOrderTime, begin, end);
        }

        // 排序条件
        queryWrapper.orderByDesc(Order::getOrderTime);

        // 执行分页查询
        this.page(pageInfo, queryWrapper);

        // 确保总数正确
        if (pageInfo.getTotal() == 0 && pageInfo.getRecords() != null && !pageInfo.getRecords().isEmpty()) {
            log.warn("商家订单分页查询返回了记录但总数为0，设置总数为记录数量: {}", pageInfo.getRecords().size());
            // 这里不能直接修改total，因为它是通过方法获取的，我们可以在日志中记录这个问题
        }

        log.info("商家订单分页查询结果: 总数={}, 当前页记录数={}",
                pageInfo.getTotal(), pageInfo.getRecords() != null ? pageInfo.getRecords().size() : 0);

        return Result.success(pageInfo);
    }

    /**
     * 查询订单详情
     */
    @Override
    public Result<Order> getOrderDetail(Long id) {
        // 查询订单基本信息
        Order order = this.getById(id);

        if (order == null) {
            return Result.error("订单不存在");
        }

        // 查询订单详情
        LambdaQueryWrapper<OrderDetail> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(OrderDetail::getOrderId, id);
        List<OrderDetail> orderDetails = orderDetailMapper.selectList(queryWrapper);

        // 设置订单详情
        order.setOrderDetails(orderDetails);

        return Result.success(order);
    }

    /**
     * 接单
     */
    @Override
    @Transactional
    public Result<String> acceptOrder(Long id) {
        Order order = this.getById(id);

        if (order == null) {
            return Result.error("订单不存在");
        }

        if (order.getStatus() != 1) {
            return Result.error("订单状态不正确");
        }

        // 更新订单状态为2（已接单）
        order.setStatus(2);
        this.updateById(order);

        return Result.success("接单成功");
    }

    /**
     * 配送订单
     */
    @Override
    @Transactional
    public Result<String> deliveryOrder(Long id) {
        Order order = this.getById(id);

        if (order == null) {
            return Result.error("订单不存在");
        }

        if (order.getStatus() != 2) {
            return Result.error("订单状态不正确");
        }

        // 更新订单状态为3（配送中）
        order.setStatus(3);
        this.updateById(order);

        return Result.success("配送成功");
    }

    /**
     * 完成订单
     */
    @Override
    @Transactional
    public Result<String> completeOrder(Long id) {
        Order order = this.getById(id);

        if (order == null) {
            return Result.error("订单不存在");
        }

        if (order.getStatus() != 3) {
            return Result.error("订单状态不正确");
        }

        // 更新订单状态为4（已完成）
        order.setStatus(4);
        this.updateById(order);

        return Result.success("订单已完成");
    }

    /**
     * 取消订单
     */
    @Override
    @Transactional
    public Result<String> cancelOrder(Long id) {
        Order order = this.getById(id);

        if (order == null) {
            return Result.error("订单不存在");
        }

        // 只有状态为1（待接单）和2（已接单）的订单可以取消
        if (order.getStatus() != 1 && order.getStatus() != 2) {
            return Result.error("订单状态不正确，无法取消");
        }

        // 更新订单状态为5（已取消）
        order.setStatus(5);
        order.setCancelTime(LocalDateTime.now());
        this.updateById(order);

        return Result.success("订单已取消");
    }

    /**
     * 支付订单
     */
    @Override
    @Transactional
    public Result<String> payOrder(Long id) {
        Order order = this.getById(id);

        if (order == null) {
            return Result.error("订单不存在");
        }

        // 只有状态为1（待接单）的订单可以支付
        if (order.getStatus() != 1) {
            return Result.error("订单状态不正确，无法支付");
        }

        // 更新订单状态为2（已接单/待配送）
        order.setStatus(2);
        order.setCheckoutTime(LocalDateTime.now());
        this.updateById(order);

        return Result.success("支付成功");
    }
}